Як я можу видалити певний елемент із масиву?

1
2
3
4
Далі
Знайдіть індекс елемента масиву, який потрібно видалити, використовуючи indexOf, а потім видаліть цей індекс за допомогою сплайсингу.
Метод splice () змінює вміст масиву, видаляючи
існуючі елементи та / або додавання нових елементів.
const масив = [2, 5, 9];
console.log (масив);
const index = array.indexOf (5);
if (індекс> -1) {
array.splice (індекс, 1);
}
// масив = [2, 9]
console.log (масив);
Другим параметром сплайсингу є кількість елементів для видалення. Зверніть увагу, що сплайсинг змінює масив на місці і повертає новий масив, що містить елементи, які були видалені.
З метою повноти, ось функції. Перша функція видаляє лише одне входження (тобто видалення першого збігу 5 із [2,5,9,1,5,8,5]), а друга функція видаляє всі випадки:
функція removeItemOnce (аргумент, значення) {
індекс var = arr.indexOf (значення);
if (індекс> -1) {
arr.splice (індекс, 1);
}
return arr;
}
функція removeItemAll (обр., значення) {
var i = 0;
while (i  = 0; i--) {
if (масив [i] === номер) {
array.splice (i, 1);
}
}
Якщо ви просто хочете, щоб елемент з індексом i більше не існував, але ви не хочете, щоб індекси інших елементів змінювались:
видалити масив [i];
|
Відредаговано 2016 жовтня
Зробіть це просто, інтуїтивно зрозуміло та чітко (бритва Оккама)
Зробити незмінним (оригінальний масив залишається незмінним)
Робіть це зі стандартними функціями JavaScript, якщо ваш браузер їх не підтримує - використовуйте polyfill
У цьому прикладі коду я використовую функцію "array.filter (...)" для видалення небажаних елементів з масиву. Ця функція не змінює вихідний масив і створює новий. Якщо ваш браузер не підтримує цю функцію (наприклад, Internet Explorer до версії 9 або Firefox до версії 1.5), спробуйте використати фільтр polyfill від Mozilla.
Видалення елемента (код ECMA-262 Edition 5, відомий як старий JavaScript)
значення var = 3
var arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (функція (елемент) {
повернути елемент! == значення
})
console.log (обр.)
// [1, 2, 4, 5]
Видалення елемента (код ECMAScript 6)
нехай значення = 3
нехай arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == value)
console.log (обр.)
// [1, 2, 4, 5]
ВАЖЛИВО ECMAScript 6 "() => {}" Синтаксис функції стрілки взагалі не підтримується в Internet Explorer, Chrome до 45, Firefox до 22 та Safari до 10. Для використання синтаксису ECMAScript 6 у старих браузерах ви можете використовувати BabelJS.
Видалення кількох елементів (код ECMAScript 7)
Додатковою перевагою цього методу є те, що ви можете видалити кілька елементів
нехай forDeletion = [2, 3, 5]
нехай arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item =>! forDeletion.includes (item))
// !!! Про підтримку array.includes (...) читайте нижче !!!
console.log (обр.)
// [1, 4]
ВАЖЛИВО: функція "array.includes (...)" взагалі не підтримується в Internet Explorer, Chrome до версії 47, Firefox до версії 43, Safari до версії 9 та Edge до версії 14, тому тут є заливка від Mozilla.
Видалення кількох елементів (можливо, у майбутньому)
Якщо пропозицію "Цей синтаксис, що зв’язує" коли-небудь буде прийнято, ви зможете зробити це:
// array-lib.js
функція експорту видалити (... forDeletion) {
повернути this.filter (item =>! forDeletion.includes (item))
}
// main.js
імпортувати {видалити} з './array-lib.js'
нехай arr = [1, 2, 3, 4, 5, 3]
// :: Ця прив'язка синтаксису
// використання функції "видалення" як "віртуального методу"
// без розширення Array.prototype
arr = arr :: remove (2, 3, 5)
console.log (arr)
// [1, 4]
Спробуйте самі в BabelJS :)
Довідково
Array.prototype.includes
Функціональний склад
|
Це залежить від того, чи хочете ви залишити порожнє місце чи ні.
Якщо ви хочете порожній слот:
масив [індекс] = невизначений;
Якщо ви не хочете порожнього слота:
// Щоб зберегти оригінал:
// oldArray = [... масив];
// Це змінює масив.
array.splice (індекс, 1);
І якщо вам потрібно значення цього елемента, ви можете просто зберегти елемент повернутого масиву:
значення var = array.splice (індекс, 1) [0];
Якщо ви хочете видалити з будь-якого кінця масиву, ви можете використовувати array.pop () для останнього або array.shift () для першого (обидва також повертають значення елемента).
Якщо ви не знаєте індекс елемента, ви можете використовувати array.indexOf (item), щоб отримати його (у if (), щоб отримати один елемент, або через деякий час (), щоб отримати їх усі). array.indexOf (item) повертає або індекс, або -1, якщо не знайдено.
|
Друг мав проблеми в Internet Explorer 8 і показав мені, що він зробив. Я сказав йому, що це неправильно, а він відповів, що отримав відповідьтут. Поточна відповідь на вершину буде працювати не у всіх браузерах (наприклад, Internet Explorer 8), і вона видалить лише перше входження елемента.
Видаліть ВСІ екземпляри з масиву
функція array_remove_index_by_value (arr, item)
{
для (var i = довжина довжини; i--;)
{
if (arr [i] === item) {arr.splice (i, 1);}
}
}
Він циклічно повертається до масиву назад (оскільки індекси та довжина змінюватимуться при видаленні елементів) і видаляє елемент, якщо його знайдено. Це працює у всіх браузерах.
|
Існує два основних підходи:
splice (): anArray.splice (індекс, 1);
delete: видалити anArray [індекс];
Будьте обережні, коли використовуєте видалення для масиву. Це добре для видалення атрибутів об’єктів, але не так добре для масивів. Краще використовувати сплайсинг для масивів.
Майте на увазі, що коли ви використовуєте delete для масиву, ви можете отримати неправильні результати для anArray.length. Іншими словами, видалення призведе до видалення елемента, але воно не оновить значення властивості length.
Ви також можете очікувати, що у вас будуть дірки в індексних номерах після використання видалення, наприклад Ви могли б отримати індекси 1, 3, 4, 8, 9 і 11 і довжину, як це було до використання видалення. У такому випадку всі індексовані цикли будуть аварійно завершувати роботу, оскільки індекси більше не є послідовними.
Якщо вас з якоїсь причини змушено використовувати видалення, тоді вам слід використовувати для кожного циклу, коли вам потрібно прокрутити масиви. По суті, завжди уникайте використання індексованих циклів, якщо це можливо. Таким чином, код був би більш надійним і менш схильним до проблем з індексами.
|
Array.prototype.remove_by_value = функція (val) {
for (var i = 0; i  row.id === 5);
var видалено = helper.remove (arr, row => row.name.startsWith ('BMW'));
## Визначення
var помічник = {
// Видалення та повернення першого входження
removeOne: function (array, предикат) {
for (var i = 0; i  [2, 3, 4]
|
Ви можете використовувати ES6. Наприклад, щоб у цьому випадку видалити значення "3":
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((value) => value! = '3');
console.log (newArray);
Вихід:
["1", "2", "4", "5", "6"]
|
Якщо вам потрібен новий масив із видаленими видаленими позиціями, ви завжди можете видалити конкретний елемент і відфільтрувати масив. Можливо, йому знадобиться розширення об’єкта масиву для браузерів, які не реалізують метод фільтра, але в довгостроковій перспективі це простіше, оскільки все, що ви робите, це:
var my_array = [1, 2, 3, 4, 5, 6];
видалити my_array [4];
console.log (my_array.filter (function (a) {return typeof a! == 'undefined';}));
Він повинен відображати [1, 2, 3, 4, 6].
|
Ось декілька способів видалити елемент із масиву за допомогою JavaScript.
Весь описаний метод не мутує вихідний масив, а натомість створює новий.
Якщо ви знаєте індекс товару
Припустимо, у вас є масив і ви хочете видалити елемент у позиції i.
Одним із методів є використання slice ():
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const i = 3
const filteredItems = items.slice (0, i) .concat (items.slice (i + 1, items.length))
console.log (filteredItems)
slice () створює новий масив з отриманими індексами. Ми просто створюємо новий масив від початку до індексу, який ми хочемо видалити, і об’єднуємо інший масив з першої позиції після тієї, яку ми видалили, до кінця масиву.
Якщо ви знаєте цінність
У цьому випадку хорошим варіантом є використання filter (), який пропонує більш декларативний підхід:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valueToRemove = 'c'
const filteredItems = items.filter (item => item! == valueToRemove)
console.log (filteredItems)
Тут використовуються функції стрілок ES6. Ви можете використовувати традиційні функції для підтримки старих браузерів:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valueToRemove = 'c'
const filteredItems = items.filter (функція (item) {
повернути елемент! == valueToRemove
})
console.log (filteredItems)
або ви можете використовувати Babel і перевести код ES6 назад на ES5, щоб зробити його більш засвоюваним для старих браузерів, але при цьому впишіть сучасний JavaScript у свій код.
Видалення декількох елементів
Що робити, якщо замість одного елемента ви хочете видалити багато елементів?
Знайдемо найпростіше рішення.
За показником
Ви можете просто створити функцію та видалити елементи послідовно:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const removeItem = (items, i) =>
items.slice (0, i-1) .concat (items.slice (i, items.length))
let filteredItems = removeItem (items, 3)
filteredItems = removeItem (filteredItems, 5)
//["а Б В Г"]
console.log (filteredItems)
За значенням
Ви можете шукати включення всередині функції зворотного виклику:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valuesToRemove = ['c', 'd']
const filteredItems = items.filter (item =>! valuesToRemove.includes (item))
// ["a", "b", "e", "f"]
console.log (filteredItems)
Уникайте мутації вихідного масиву
splice () (не плутати з slice ()) мутує вихідний масив і його слід уникати.
(спочатку розміщено на моєму сайті https://flaviocopes.com/how-to-remove-item-from-array/)
|
Перевірте цей код. Це працює в кожному великому браузері.
remove_item = функція (arr, значення) {
var b = '';
for (b in arr) {
if (arr [b] === значення) {
обр. зріз (b, 1);
перерву;
}
}
return arr;
};
Виклик цієї функції
remove_item (масив, значення);
|
ES6 та без мутації: (жовтень 2016)
const removeByIndex = (список, індекс) =>
[
... list.slice (0, індекс),
... list.slice (індекс + 1)
];
output = removeByIndex ([33,22,11,44], 1) // => [33,11,44]
console.log (вихід)
|
Ви можете використовувати lodash _.pull (змінити масив), _.pullAt (змінити масив) або _.without (не змінювати масив),
var array1 = ['a', 'b', 'c', 'd']
_.pull (масив1, 'c')
console.log (array1) // ['a', 'b', 'd']
var array2 = ['e', 'f', 'g', 'h']
_.pullAt (масив2, 0)
console.log (array2) // ['f', 'g', 'h']
var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without (array3, 'i') // ['j', 'k', 'l']
console.log (array3) // ['i', 'j', 'k', 'l']
|
Видалення певного елемента / рядка з масиву можна здійснити за допомогою одного рядка:
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
де:
theArray: масив, з якого ви хочете видалити щось конкретне
stringToRemoveFromArray: рядок, який потрібно видалити, а 1 - кількість елементів, які потрібно видалити.
ПРИМІТКА: Якщо "stringToRemoveFromArray" не знаходиться у вашому масиві, це видалить останній елемент масиву.
Завжди хороша практика - перевірити, чи існує елемент у вашому масиві спочатку, перед тим, як його видалити.
якщо (theArray.indexOf ("stringToRemoveFromArray")> = 0) {
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
}
Якщо у вас є доступ до нових версій Ecmascript на комп’ютерах вашого клієнта (ПОПЕРЕДЖЕННЯ, можливо, не працює на старих станціях):
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((value) => value! = '3');
Де '3' - значення, яке ви хочете видалити з масиву.
Потім масив стане: ['1', '2', '4', '5', '6']
|
Добре, наприклад, у вас є масив нижче:
змінне число = [1, 2, 3, 4, 5];
І ми хочемо видалити номер 4. Ви можете просто використати наведений нижче код:
num.splice (num.indexOf (4), 1); // число буде [1, 2, 3, 5];
Якщо ви повторно використовуєте цю функцію, ви пишете функцію багаторазового використання, яка буде приєднана до власної функції масиву, як показано нижче:
Array.prototype.remove = Array.prototype.remove || функція (x) {
const i = this.indexOf (x);
якщо (i === - 1)
повернення;
this.splice (i, 1); // num.remove (5) === [1, 2, 3];
}
Але як щодо того, якщо замість цього у вас є масив, наведений нижче, з кількома [5] с?
змінне число = [5, 6, 5, 4, 5, 1, 5];
Нам потрібен цикл, щоб перевірити їх усі, але простішим та ефективнішим способом є використання вбудованих функцій JavaScript, тому ми пишемо функцію, яка використовує замість цього фільтр:
const _removeValue = (arr, x) => arr.filter (n => n! == x);
// _ removeValue ([1, 2, 3, 4, 5, 5, 6, 5], 5) // Повернення [1, 2, 3, 4, 6]
Також існують сторонні бібліотеки, які допомагають вам це зробити, наприклад, Lodash або Underscore. Для отримання додаткової інформації дивіться на lodash _.pull, _.pullAt або _.without.
|
Продуктивність
Сьогодні (2019-12-09) я проводжу тести продуктивності macOS v10.13.6 (High Sierra) для обраних рішень. Я показую delete (A), але не використовую його порівняно з іншими методами, оскільки це залишило порожній простір у масиві.
Висновки
найшвидше рішення - array.splice (C) (за винятком Safari для невеликих масивів, де він має другий раз)
для великих масивів array.slice + сплайс (H) є найшвидшим незмінним рішенням для Firefox та Safari; Array.from (B) є найшвидшим у Chrome
змінні розчини, як правило, в 1,5x-6x швидші, ніж незмінні
для невеликих таблиць у Safari, напрочуд змінне рішення (C) повільніше, ніж незмінне рішення (G)
Деталі
У тестах я видаляю середній елемент із масиву різними способами. Рішення A, C є на місці. Розчини B, D, E, F, G, H є незмінними.
Результати для масиву з 10 елементами
У Chrome array.splice (C) є найшвидшим рішенням на місці. Array.filter (D) є найшвидшим незмінним рішенням. Найповільнішим є array.slice (F). Ви можете провести тест на своїй машині тут.
Результати для масиву з 1.000.000 елементами
У Chrome array.splice (C) є найшвидшим рішенням на місці (видалення (C) подібне швидко - але це залишило порожній слот в масиві (тому він не виконує "повного видалення")). Array.slice-splice (H) є найшвидшим незмінним рішенням. Найповільнішим є array.filter (D і E). Ви можете провести тест на своїй машині тут.
var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter, array) => console.log (letter, array.join `,`);
функція A (масив) {
індекс var = array.indexOf (5);
видалити масив [індекс];
log ('A', масив);
}
функція B (масив) {
індекс var = array.indexOf (5);
var arr = Array.from (масив);
arr.splice (індекс, 1)
log ('B', arr);
}
функція C (масив) {
індекс var = array.indexOf (5);
array.splice (індекс, 1);
log ('C', масив);
}
функція D (масив) {
var arr = array.filter (item => item! == 5)
log ('D', arr);
}
функція E (масив) {
індекс var = array.indexOf (5);
var arr = array.filter ((item, i) => i! == index)
log ('E', arr);
}
функція F (масив) {
індекс var = array.indexOf (5);
var arr = array.slice (0, index) .concat (array.slice (index + 1))
log ('F', arr);
}
функція G (масив) {
індекс var = array.indexOf (5);
var arr = [... array.slice (0, index), ... array.slice (index + 1)]
log ('G', arr);
}
функція H (масив) {
індекс var = array.indexOf (5);
var arr = array.slice (0);
arr.splice (індекс, 1);
log ('H', arr);
}
A ([... a]);
B ([... a]);
C ([... a]);
D ([... a]);
E ([... a]);
F ([... a]);
G ([... a]);
H ([... a]);
Цей фрагмент представляє лише код, який використовується в тестах продуктивності - він не виконує тести сам.
Порівняння для браузерів: Chrome v78.0.0, Safari v13.0.4 та Firefox v71.0.0
|
Я досить новачок у JavaScript і потребував цієї функціональності. Я просто написав це:
функція removeFromArray (масив, елемент, індекс) {
while ((index = array.indexOf (item))> -1) {
array.splice (індекс, 1);
}
}
Тоді, коли я хочу його використовувати:
// Налаштування деяких фіктивних даних
var dummyObj = {name: "нявкати"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];
// Видалення фіктивних даних
removeFromArray (dummyArray, dummyObj);
removeFromArray (dummyArray, "item2");
Результат - як очікувалося.
["item1", "item1"]
У вас можуть бути інші потреби, ніж у мене, тому ви можете легко їх змінитиїх влаштовувати. Сподіваюся, це комусь допомагає.
|
Якщо у вас є складні об'єкти в масиві, ви можете використовувати фільтри?
У ситуаціях, коли $ .inArray або array.splice не так прості у використанні. Особливо, якщо об’єкти, можливо, неглибокі в масиві.
Наприклад якщо у вас є об’єкт із полем Id і ви хочете, щоб об’єкт був видалений з масиву:
this.array = this.array.filter (function (element, i) {
повернути елемент.id! == idToRemove;
});
|
Я хочу відповісти на основі ECMAScript 6. Припустимо, у вас є масив, як показано нижче:
нехай arr = [1,2,3,4];
Якщо ви хочете видалити за спеціальним індексом, наприклад 2, напишіть код нижче:
обр. сплайс (2, 1); // => arr став [1,2,4]
Але якщо ви хочете видалити спеціальний елемент, такий як 3, і ви не знаєте його індекс, зробіть, як показано нижче:
arr = arr.filter (e => e! == 3); // => arr став [1,2,4]
Підказка: використовуйте функцію стрілки для зворотного виклику фільтра, якщо ви не отримаєте порожній масив.
|
Оновлення: цей метод рекомендується лише у тому випадку, якщо ви не можете використовувати ECMAScript 2015 (раніше відомий як ES6). Якщо ви можете ним скористатися, інші відповіді тут дають набагато акуратніші реалізації.
Цей суть тут вирішить вашу проблему, а також видалить усі випадки аргументу замість лише 1 (або вказаного значення).
Array.prototype.destroy = function (obj) {
// Повернути значення null, якщо не було знайдено та видалено об'єктів
var знищений = null;
for (var i = 0; i  3
x.destroy (false); // => false
х; // => [1, 2, true, undefined]
x.destroy (правда); // => правда
x.destroy (невизначено); // => невизначений
х; // => [1, 2]
x.destroy (3); // => нуль
х; // => [1, 2]
|
Оновлення ES10
Ця публікація узагальнює загальні підходи до видалення елементів із масиву станом на ECMAScript 2019 (ES10).
1. Загальні випадки
1.1. Видалення елемента масиву за значенням за допомогою .splice ()
| На місці: Так |
| Видаляє дублікати: Так (цикл), Ні (indexOf) |
| За значенням / індексом: За індексом |
Якщо ви знаєте значення, яке потрібно видалити з масиву, ви можете скористатися методом сплайсингу. Спочатку ви повинні визначити індекс цільового елемента. Потім ви використовуєте індекс як початковий елемент і видаляєте лише один елемент.
// З циклом 'for'
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for (нехай i = 0; i  [1, 2, 3, 4, 6, 7, 8, 9, 0]
// За допомогою методу .indexOf ()
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf (5);
arr.splice (i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
1.2. Видалення елемента масиву за допомогою методу .filter ()
| На місці: Ні |
| Видаляє дублікати: Так |
| За значенням / індексом: За значенням |
Конкретний елемент можна відфільтрувати з масиву, надавши функцію фільтрації. Потім така функція викликається для кожного елемента масиву.
const значення = 3
нехай arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == value)
console.log (arr)
// [1, 2, 4, 5]
1.3. Видалення елемента Array шляхом розширення Array.prototype
| На місці: Так / Ні (залежить від реалізації) |
| Видаляє дублікати: Так / Ні (Залежно від реалізації) |
| За значенням / індексом: За індексом / За значенням (Залежить від реалізації) |
Прототип масиву можна розширити за допомогою додаткових методів. Потім такі методи будуть доступні для використання на створених масивах.
Примітка: Розширення прототипів об’єктів зі стандартної бібліотеки JavaScript (наприклад, Array) дехто розглядає як шаблон.
// На місці, видаляє все, шляхом реалізації значення
Array.prototype.remove = функція (елемент) {
для (нехай i = 0; i  = ES10)
| На місці: Ні |
| Видаляє дублікати: Так |
| За значенням / індексом: За значенням |
ES10 представив Object.fromEntries, який може бутивикористовується для створення бажаного масиву з будь-якого схожого на масив об’єкта та фільтрації небажаних елементів під час процесу.
const-об'єкт = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values ​​(Object.fromEntries (
Object.entries (об'єкт)
.filter (([key, val]) => val! == valueToRemove)
));
console.log (arr); // [1,2,4]
2. Особливі випадки
2.1 Видалення елемента, якщо він знаходиться в кінці масиву
2.1.1. Зміна довжини масиву
| На місці: Так |
| Видаляє дублікати: Ні |
| За значенням / індексом: Не застосовується |
Елементи масиву JavaScript можна видалити з кінця масиву, встановивши для властивості length значення менше, ніж поточне значення. Будь-який елемент, індекс якого перевищує або дорівнює новій довжині, буде видалено.
const arr = [1, 2, 3, 4, 5, 6];
довжина прибл. = 5; // Встановити довжину для видалення елемента
console.log (arr); // [1, 2, 3, 4, 5]
2.1.2. Використання методу .pop ()
| На місці: Так |
| Видаляє дублікати: Ні |
| За значенням / індексом: Не застосовується |
Метод pop видаляє останній елемент масиву, повертає цей елемент та оновлює властивість length. Метод pop модифікує масив, для якого він викликається. Це означає, на відміну від використання delete, останній елемент видаляється повністю і довжина масиву зменшується.
const arr = [1, 2, 3, 4, 5, 6];
arr.pop (); // повертає 6
console.log (arr); // [1, 2, 3, 4, 5]
2.2. Видалення елемента, якщо він знаходиться на початку масиву
| На місці: Так |
| Видаляє дублікати: Ні |
| За значенням / індексом: Не застосовується |
Метод .shift () працює майже так само, як метод pop, за винятком того, що він видаляє перший елемент масиву JavaScript замість останнього. Коли елемент вилучено, інші елементи зміщуються вниз.
const arr = [1, 2, 3, 4];
arr.shift (); // повертає 1
console.log (arr); // [2, 3, 4]
2.3. Видалення елемента, якщо це єдиний елемент у масиві
| На місці: Так |
| Видаляє дублікати: N / A |
| За значенням / індексом: Не застосовується |
Найшвидший прийом - встановити для змінної масиву порожній масив.
нехай arr = [1];
arr = []; // порожній масив
В якості альтернативи можна використовувати техніку з 2.1.1, встановивши довжину на 0.
|
Ви ніколи не повинні мутувати ваш масив. Оскільки це суперечить шаблону функціонального програмування. Ви можете створити новий масив без посилання на масив, для якого потрібно змінити дані, використовуючи фільтр методу ECMAScript 6;
var myArray = [1, 2, 3, 4, 5, 6];
Припустимо, ви хочете видалити 5 з масиву, ви можете просто зробити це так:
myArray = myArray.filter (значення => значення! == 5);
Це дасть вам новий масив без значення, яке ви хотіли видалити. Тож результат буде:
[1, 2, 3, 4, 6]; // 5 було видалено з цього масиву
Для подальшого розуміння ви можете прочитати документацію MDN на Array.filter.
|
Більш сучасний підхід ECMAScript 2015 (раніше відомий як Harmony або ES 6). Дано:
const items = [1, 2, 3, 4];
індекс const = 2;
Тоді:
items.filter ((x, i) => i! == індекс);
Урожайність:
[1, 2, 4]
Ви можете використовувати Babel та службу поліфілу, щоб переконатися, що це добре підтримується у всіх браузерах.
|
Ви можете зробити зворотний цикл, щоб не перекручувати індекси, якщо є кілька екземплярів елемента.
var myElement = "шоколад";
var myArray = ['шоколад', 'poptart', 'poptart', 'poptart', 'шоколад', 'poptart', 'poptart', 'шоколад'];
/ * Важливий код * /
для (var i = myArray.length - 1; i> = 0; i--) {
if (myArray [i] == myElement) myArray.splice (i, 1);
}
console.log (myArray);
Демо в прямому ефірі
|
У вас є від 1 до 9 у масиві, і ви хочете видалити 5. Використовуйте наведений нижче код:
змінний номерArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
повернення m! == 5;
});
console.log ("новий масив, 5 видалено", newNumberArray);
Якщо потрібно кілька значень. Приклад: - 1,7,8
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
повернення (m! == 1) && (m! == 7) && (m! == 8);
});
console.log ("новий масив, 1,7 та 8 видалено", newNumberArray);
Якщо ви хочете видалити значення масиву з масиву. Приклад: [3,4,5]
змінний номерArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];
var newNumberArray = numberArray.filter (m => {
return! removebleArray.includes (m);
});
console.log ("новий масив, [3,4,5] видалено", newNumberArray);
Включає підтримуваний браузер посилання.
|
1
2
3
4
Далі
Високоактивне запитання. Заробіть 10 репутації, щоб відповісти на це питання. Вимога про репутацію допомагає захистити це питання від спаму та відсутності відповідей.
Не відповідь, яку ви шукаєте? Перегляньте інші запитання, позначені масивами javascript, або задайте власне запитання.